///
/// @file Antlr4CSTVisitor.cpp
/// @brief Antlr4的具体语法树的遍历产生AST
/// @author zenglj (zenglj@live.com)
/// @version 1.1
/// @date 2024-11-23
///
/// @copyright Copyright (c) 2024
///
/// @par 修改日志:
/// <table>
/// <tr><th>Date       <th>Version <th>Author  <th>Description
/// <tr><td>2024-09-29 <td>1.0     <td>zenglj  <td>新建
/// <tr><td>2024-11-23 <td>1.1     <td>zenglj  <td>表达式版增强
/// </table>
///

#include <string>
#include <cctype>

#include "Antlr4CSTVisitor.h"
#include "AST.h"
#include "AttrType.h"
#include <IntegerType.h>
#include <FloatType.h>
#include <VoidType.h>
#include <cmath>

#define Instanceof(res, type, var) auto res = dynamic_cast<type>(var)

// 前向声明静态函数
static bool isValidTypeDeclaration(const std::string & typeStr);
static ast_node * parseTypeFromCast(const std::string & castText);

// 新增：检测字符串是否为有效的类型声明
static bool isValidTypeDeclaration(const std::string & typeStr)
{
    // 去除首尾空白
    std::string trimmed = typeStr;
    while (!trimmed.empty() && std::isspace(trimmed[0])) {
        trimmed.erase(0, 1);
    }
    while (!trimmed.empty() && std::isspace(trimmed.back())) {
        trimmed.pop_back();
    }

    if (trimmed.empty())
        return false;

    // 检查是否以基本类型开头
    bool startsWithValidType = false;
    if (trimmed.length() >= 3 && trimmed.substr(0, 3) == "int") {
        startsWithValidType = true;
        trimmed = trimmed.substr(3);
    } else if (trimmed.length() >= 5 && trimmed.substr(0, 5) == "float") {
        startsWithValidType = true;
        trimmed = trimmed.substr(5);
    } else if (trimmed.length() >= 4 && trimmed.substr(0, 4) == "void") {
        startsWithValidType = true;
        trimmed = trimmed.substr(4);
    }

    if (!startsWithValidType)
        return false;

    // 去除类型名后的空白
    while (!trimmed.empty() && std::isspace(trimmed[0])) {
        trimmed.erase(0, 1);
    }

    // 检查后续是否只包含 * 和空白
    for (char c: trimmed) {
        if (c != '*' && !std::isspace(c)) {
            return false;
        }
    }

    return true;
}

// 修改：解析类型转换中的具体类型，将void*当作i32处理
static ast_node * parseTypeFromCast(const std::string & castText)
{
    // 提取括号内的类型信息
    size_t start = castText.find('(');
    size_t end = castText.find(')');
    if (start == std::string::npos || end == std::string::npos || start >= end) {
        // 默认返回int类型节点（当作i32）
        auto intNode = new ast_node(ast_operator_type::AST_OP_LEAF_TYPE);
        intNode->type = IntegerType::getTypeInt();
        intNode->name = "int";
        return intNode;
    }

    std::string typeStr = castText.substr(start + 1, end - start - 1);

    // 统计指针级别
    int ptrLevel = 0;
    size_t pos = typeStr.find('*');
    while (pos != std::string::npos) {
        ptrLevel++;
        pos = typeStr.find('*', pos + 1);
    }

    // 提取基本类型
    std::string baseTypeStr = typeStr;
    while (!baseTypeStr.empty() && (baseTypeStr.back() == '*' || baseTypeStr.back() == ' ')) {
        baseTypeStr.pop_back();
    }

    // 对于void*指针类型，直接当作int类型处理
    if (baseTypeStr == "void" && ptrLevel > 0) {
        auto intNode = new ast_node(ast_operator_type::AST_OP_LEAF_TYPE);
        intNode->type = IntegerType::getTypeInt();
        intNode->name = "int";
        return intNode;
    }

    // 创建类型节点
    auto typeNode = new ast_node(ast_operator_type::AST_OP_LEAF_TYPE);

    // 根据基本类型设置名称和类型
    if (baseTypeStr == "int") {
        typeNode->type = IntegerType::getTypeInt();
        typeNode->name = "int";
    } else if (baseTypeStr == "float") {
        typeNode->type = FloatType::getTypeFloat();
        typeNode->name = "float";
    } else if (baseTypeStr == "void") {
        typeNode->type = VoidType::getType();
        typeNode->name = "void";
    } else {
        // 默认为int类型
        typeNode->type = IntegerType::getTypeInt();
        typeNode->name = "int";
    }

    return typeNode;
}

/// @brief 构造函数
MiniCCSTVisitor::MiniCCSTVisitor()
{}

/// @brief 析构函数
MiniCCSTVisitor::~MiniCCSTVisitor()
{}

/// @brief 遍历CST产生AST
/// @param root CST语法树的根结点
/// @return AST的根节点
ast_node * MiniCCSTVisitor::run(MiniCParser::CompileUnitContext * root)
{
    return std::any_cast<ast_node *>(visitCompileUnit(root));
}

// 新增：处理数组初始化器的访问方法
std::any MiniCCSTVisitor::visitArrayInitializer(MiniCParser::ArrayInitializerContext * ctx)
{
    // 创建数组初始化节点
    auto arrayInitNode = create_contain_node(ast_operator_type::AST_OP_ARRAY_INIT);

    // 遍历所有的子表达式或子初始化器
    for (size_t i = 0; i < ctx->children.size(); i++) {
        // 跳过花括号和逗号
        if (ctx->children[i]->getText() == "{" || ctx->children[i]->getText() == "}" ||
            ctx->children[i]->getText() == ",") {
            continue;
        }

        // 如果是嵌套的初始化器
        if (auto subInit = dynamic_cast<MiniCParser::ArrayInitializerContext *>(ctx->children[i])) {
            auto subInitNode = std::any_cast<ast_node *>(visitArrayInitializer(subInit));
            // 嵌套的初始化器已经创建了array_init节点，直接添加
            arrayInitNode->insert_son_node(subInitNode);
        }
        // 如果是表达式
        else if (auto exprCtx = dynamic_cast<MiniCParser::ExprContext *>(ctx->children[i])) {
            auto exprNode = std::any_cast<ast_node *>(visitExpr(exprCtx));
            // 表达式直接作为array_init的子节点
            arrayInitNode->insert_son_node(exprNode);
        }
    }

    return arrayInitNode;
}

/// @brief 非终结运算符compileUnit的遍历
/// @param ctx CST上下文
std::any MiniCCSTVisitor::visitCompileUnit(MiniCParser::CompileUnitContext * ctx)
{
    // compileUnit: ((T_EXTERN)? (funcDef | varDecl | constDecl))* EOF

    // 请注意这里必须先遍历全局变量后遍历函数。肯定可以确保全局变量先声明后使用的规则，但有些情况却不能检查出。
    // 事实上可能函数A后全局变量B后函数C，这时在函数A中是不能使用变量B的，需要报语义错误，但目前的处理不会。
    // 因此在进行语义检查时，可能追加检查行号和列号，如果函数的行号/列号在全局变量的行号/列号的前面则需要报语义错误
    // TODO 请追加实现。

    ast_node * temp_node;
    ast_node * compileUnitNode = create_contain_node(ast_operator_type::AST_OP_COMPILE_UNIT);

    // 可能多个常量声明，因此必须循环遍历
    for (auto constCtx: ctx->constDecl()) {
        // 常量声明
        temp_node = std::any_cast<ast_node *>(visitConstDecl(constCtx));
        (void) compileUnitNode->insert_son_node(temp_node);
    }

    // 新增：可能多个宏定义，因此必须循环遍历
    for (auto defineCtx: ctx->defineDecl()) {
        // 宏定义声明
        temp_node = std::any_cast<ast_node *>(visitDefineDecl(defineCtx));
        (void) compileUnitNode->insert_son_node(temp_node);
    }

    // 可能多个变量，因此必须循环遍历
    for (auto varCtx: ctx->varDecl()) {
        // 变量函数定义
        temp_node = std::any_cast<ast_node *>(visitVarDecl(varCtx));
        (void) compileUnitNode->insert_son_node(temp_node);
    }

    // 可能有多个函数，因此必须循环遍历
    for (auto funcCtx: ctx->funcDef()) {
        // 变量函数定义
        temp_node = std::any_cast<ast_node *>(visitFuncDef(funcCtx));
        (void) compileUnitNode->insert_son_node(temp_node);
    }

    return compileUnitNode;
}

/// @brief 非终结运算符funcDef的遍历
/// @param ctx CST上下文
std::any MiniCCSTVisitor::visitFuncDef(MiniCParser::FuncDefContext * ctx)
{
    // 修改：函数返回类型支持 int, float, void
    type_attr funcReturnType;
    if (ctx->T_INT()) {
        funcReturnType.type = BasicType::TYPE_INT;
        funcReturnType.lineno = (int64_t) ctx->T_INT()->getSymbol()->getLine();
    } else if (ctx->T_FLOAT()) {
        funcReturnType.type = BasicType::TYPE_FLOAT;
        funcReturnType.lineno = (int64_t) ctx->T_FLOAT()->getSymbol()->getLine();
    } else if (ctx->T_VOID()) {
        funcReturnType.type = BasicType::TYPE_VOID;
        funcReturnType.lineno = (int64_t) ctx->T_VOID()->getSymbol()->getLine();
    }

    // 创建函数名的标识符终结符节点
    char * id = strdup(ctx->T_ID()->getText().c_str());
    var_id_attr funcId{id, (int64_t) ctx->T_ID()->getSymbol()->getLine()};

    // 处理函数形参列表（如果存在）
    ast_node * formalParamsNode = nullptr;
    if (ctx->funcFParams()) {
        formalParamsNode = std::any_cast<ast_node *>(visitFuncFParams(ctx->funcFParams()));
    }

    auto blockNode = std::any_cast<ast_node *>(visitBlock(ctx->block()));

    // 创建函数定义节点
    return create_func_def(funcReturnType, funcId, blockNode, formalParamsNode);
}

// 新增：处理函数形参列表：funcFParams: funcFParam (',' funcFParam)*;
std::any MiniCCSTVisitor::visitFuncFParams(MiniCParser::FuncFParamsContext * ctx)
{
    // 创建形式参数列表结点（AST_OP_FUNC_FORMAL_PARAMS）
    ast_node * paramsNode = new ast_node(ast_operator_type::AST_OP_FUNC_FORMAL_PARAMS);
    // 遍历所有 funcFParam 子结点
    for (auto paramCtx: ctx->funcFParam()) {
        ast_node * paramNode = std::any_cast<ast_node *>(visitFuncFParam(paramCtx));
        paramsNode->insert_son_node(paramNode);
    }
    return paramsNode;
}

// 更新：处理单个形参：funcFParam: basicType T_ID ('[' (expr)? ']' ('[' expr ']')?)?;
std::any MiniCCSTVisitor::visitFuncFParam(MiniCParser::FuncFParamContext * ctx)
{
    // 解析基本类型属性
    type_attr attr = std::any_cast<type_attr>(visitBasicType(ctx->basicType()));
    Type * paramType = typeAttr2Type(attr);

    // 获取形参名字和行号
    std::string paramName = ctx->T_ID()->getText();
    int64_t lineNo = (int64_t) ctx->T_ID()->getSymbol()->getLine();

    // 创建维度节点（如果存在数组声明）
    ast_node * dimNode = nullptr;
    auto brackets = ctx->getTokens(MiniCParser::T_L_BRACKET);
    auto exprs = ctx->expr();

    if (!brackets.empty()) {
        ast_node * last = nullptr;
        size_t exprIdx = 0;
        for (size_t i = 0; i < brackets.size(); ++i) {
            ast_node * currentDim = new ast_node(ast_operator_type::AST_OP_ARRAY_DIM);
            // 只有非空维度才消耗一个 expr
            if (exprIdx < exprs.size() &&
                exprs[exprIdx]->getStart()->getTokenIndex() > brackets[i]->getSymbol()->getTokenIndex()) {
                auto exprNode = std::any_cast<ast_node *>(visitExpr(exprs[exprIdx]));
                currentDim->insert_son_node(exprNode);
                ++exprIdx;
            }
            if (last) {
                currentDim->insert_son_node(last);
            }
            last = currentDim;
        }
        dimNode = last;
    }

    // 构造完 dimNode 后，调整空维度到最底层
    if (dimNode && dimNode->is_empty_dim()) {
        ast_node * cur = dimNode;
        // ast_node* prev = nullptr;
        // 找到最后一个维度节点
        while (cur->sons[0]->is_array_dim()) {
            // prev = cur;
            cur = cur->sons[0];
        }
        while (cur->sons.size() > 1 && cur->sons[1]->is_array_dim()) {
            // prev = cur;
            cur = cur->sons[1];
        }
        // 把空维度挪到最后
        // if (prev) {
        // prev->sons[0] = cur; // 断开空维度
        ast_node * emptyDim = dimNode;
        dimNode = dimNode->sons[0];     // 新的顶层
        cur->insert_son_node(emptyDim); // 挂到最底层
        emptyDim->sons.clear();         // 清空原有子节点
        // }
    }

    // 创建形式参数节点
    return create_func_formal_param(lineNo, paramName.c_str(), paramType, dimNode);
}

/// @brief 非终结运算符block的遍历
/// @param ctx CST上下文
std::any MiniCCSTVisitor::visitBlock(MiniCParser::BlockContext * ctx)
{
    // 识别的文法产生式：block : T_L_BRACE blockItemList? T_R_BRACE';
    if (!ctx->blockItemList()) {
        // 语句块没有语句

        // 为了方便创建一个空的Block节点
        return create_contain_node(ast_operator_type::AST_OP_BLOCK);
    }

    // 语句块含有语句

    // 内部创建Block节点，并把语句加入，这里不需要创建Block节点
    return visitBlockItemList(ctx->blockItemList());
}

/// @brief 非终结运算符blockItemList的遍历
/// @param ctx CST上下文
std::any MiniCCSTVisitor::visitBlockItemList(MiniCParser::BlockItemListContext * ctx)
{
    // 识别的文法产生式：blockItemList : blockItem +;
    // 正闭包 循环 至少一个blockItem
    auto block_node = create_contain_node(ast_operator_type::AST_OP_BLOCK);

    for (auto blockItemCtx: ctx->blockItem()) {

        // 非终结符，需遍历
        auto blockItem = std::any_cast<ast_node *>(visitBlockItem(blockItemCtx));

        // 插入到块节点中
        (void) block_node->insert_son_node(blockItem);
    }

    return block_node;
}

///
/// @brief 非终结运算符blockItem的遍历
/// @param ctx CST上下文
///
std::any MiniCCSTVisitor::visitBlockItem(MiniCParser::BlockItemContext * ctx)
{
    // 识别的文法产生式：blockItem : statement | varDecl | constDecl
    if (ctx->statement()) {
        return visitStatement(ctx->statement());
    } else if (ctx->varDecl()) {
        return visitVarDecl(ctx->varDecl());
    } else if (ctx->constDecl()) {
        return visitConstDecl(ctx->constDecl());
    }
    return std::any((ast_node *) nullptr);
}

/// @brief 非终结运算符statement中的遍历
/// @param ctx CST上下文
std::any MiniCCSTVisitor::visitStatement(MiniCParser::StatementContext * ctx)
{
    if (Instanceof(assignCtx, MiniCParser::AssignStatementContext *, ctx)) {
        return visitAssignStatement(assignCtx);
    } else if (Instanceof(returnCtx, MiniCParser::ReturnStatementContext *, ctx)) {
        return visitReturnStatement(returnCtx);
    } else if (Instanceof(blockCtx, MiniCParser::BlockStatementContext *, ctx)) {
        return visitBlockStatement(blockCtx);
    } else if (Instanceof(exprStmtCtx, MiniCParser::ExpressionStatementContext *, ctx)) {
        return visitExpressionStatement(exprStmtCtx);
    } else if (Instanceof(ifCtx, MiniCParser::IfStatementContext *, ctx)) {
        return visitIfStatement(ifCtx);
    } else if (Instanceof(whileCtx, MiniCParser::WhileStatementContext *, ctx)) {
        return visitWhileStatement(whileCtx);
    } else if (Instanceof(breakCtx, MiniCParser::BreakStatementContext *, ctx)) {
        return visitBreakStatement(breakCtx);
    } else if (Instanceof(continueCtx, MiniCParser::ContinueStatementContext *, ctx)) {
        return visitContinueStatement(continueCtx);
    }
    return std::any((ast_node *) nullptr);
}

///
/// @brief 非终结运算符statement中的returnStatement的遍历
/// @param ctx CST上下文
///
std::any MiniCCSTVisitor::visitReturnStatement(MiniCParser::ReturnStatementContext * ctx)
{
    // 识别的文法产生式：returnStatement -> T_RETURN expr? T_SEMICOLON

    if (ctx->expr()) {
        // 有返回表达式的情况
        auto exprNode = std::any_cast<ast_node *>(visitExpr(ctx->expr()));
        return create_contain_node(ast_operator_type::AST_OP_RETURN, exprNode);
    } else {
        // 没有返回表达式的情况（如 return;）
        return create_contain_node(ast_operator_type::AST_OP_RETURN);
    }
}

/// @brief 非终结运算符expr的遍历
/// @param ctx CST上下文
std::any MiniCCSTVisitor::visitExpr(MiniCParser::ExprContext * ctx)
{
    auto node = std::any_cast<ast_node *>(visitLorExp(ctx->lorExp()));
    // 新增：宏替换
    node = tryReplaceDefine(node);
    return node;
}

// 新增：逻辑或表达式遍历，形如 landExp (T_LOR landExp)*;
std::any MiniCCSTVisitor::visitLorExp(MiniCParser::LorExpContext * ctx)
{
    if (ctx->T_LOR().empty()) {
        return visitLandExp(ctx->landExp()[0]);
    }
    ast_node *left, *right;
    auto ops = ctx->T_LOR();
    for (int i = 0; i < (int) ops.size(); i++) {
        if (i == 0) {
            left = std::any_cast<ast_node *>(visitLandExp(ctx->landExp()[i]));
        }
        right = std::any_cast<ast_node *>(visitLandExp(ctx->landExp()[i + 1]));
        left = ast_node::New(ast_operator_type::AST_OP_LOR, left, right, nullptr);
    }
    return left;
}

// 新增：逻辑与表达式遍历，形如 eqExp (T_LAND eqExp)*;
std::any MiniCCSTVisitor::visitLandExp(MiniCParser::LandExpContext * ctx)
{
    if (ctx->T_LAND().empty()) {
        return visitEqExp(ctx->eqExp()[0]);
    }
    ast_node *left, *right;
    auto ops = ctx->T_LAND();
    for (int i = 0; i < (int) ops.size(); i++) {
        if (i == 0) {
            left = std::any_cast<ast_node *>(visitEqExp(ctx->eqExp()[i]));
        }
        right = std::any_cast<ast_node *>(visitEqExp(ctx->eqExp()[i + 1]));
        left = ast_node::New(ast_operator_type::AST_OP_LAND, left, right, nullptr);
    }
    return left;
}

// 新增：相等表达式的遍历，形如 relExp (eqOp relExp)*;
std::any MiniCCSTVisitor::visitEqExp(MiniCParser::EqExpContext * ctx)
{
    if (ctx->eqOp().empty()) {
        return visitRelExp(ctx->relExp()[0]);
    }
    ast_node *left, *right;
    auto opsCtxVec = ctx->eqOp();
    for (int k = 0; k < (int) opsCtxVec.size(); k++) {
        if (k == 0) {
            left = std::any_cast<ast_node *>(visitRelExp(ctx->relExp()[k]));
        }
        right = std::any_cast<ast_node *>(visitRelExp(ctx->relExp()[k + 1]));
        ast_operator_type op = std::any_cast<ast_operator_type>(visitEqOp(opsCtxVec[k]));
        left = ast_node::New(op, left, right, nullptr);
    }
    return left;
}

// 新增：处理相等运算符 (==, !=)
std::any MiniCCSTVisitor::visitEqOp(MiniCParser::EqOpContext * ctx)
{
    if (ctx->T_EQ()) {
        return ast_operator_type::AST_OP_EQ;
    } else if (ctx->T_NEQ()) {
        return ast_operator_type::AST_OP_NEQ;
    }
    return nullptr;
}

// 新增：关系表达式节点的遍历，形如 addExp (relOp addExp)*;
std::any MiniCCSTVisitor::visitRelExp(MiniCParser::RelExpContext * ctx)
{
    if (ctx->relOp().empty()) {
        return visitAddExp(ctx->addExp()[0]);
    }
    ast_node *left, *right;
    auto opsCtxVec = ctx->relOp();
    for (int k = 0; k < (int) opsCtxVec.size(); k++) {
        if (k == 0) {
            left = std::any_cast<ast_node *>(visitAddExp(ctx->addExp()[k]));
        }
        right = std::any_cast<ast_node *>(visitAddExp(ctx->addExp()[k + 1]));
        ast_operator_type op = std::any_cast<ast_operator_type>(visitRelOp(opsCtxVec[k]));
        left = ast_node::New(op, left, right, nullptr);
    }
    return left;
}

// 新增：处理关系运算符 (<, >, <=, >=)
std::any MiniCCSTVisitor::visitRelOp(MiniCParser::RelOpContext * ctx)
{
    if (ctx->T_LT()) {
        return ast_operator_type::AST_OP_LESS;
    } else if (ctx->T_GT()) {
        return ast_operator_type::AST_OP_GREATER;
    } else if (ctx->T_LE()) {
        return ast_operator_type::AST_OP_LESS_EQUAL;
    } else if (ctx->T_GE()) {
        return ast_operator_type::AST_OP_GREATER_EQUAL;
    }
    return nullptr;
}

std::any MiniCCSTVisitor::visitAssignStatement(MiniCParser::AssignStatementContext * ctx)
{
    // 识别文法产生式：assignStatement: lVal T_ASSIGN expr T_SEMICOLON

    // 赋值左侧左值Lval遍历产生节点
    auto lvalNode = std::any_cast<ast_node *>(visitLVal(ctx->lVal()));

    // 赋值右侧expr遍历
    auto exprNode = std::any_cast<ast_node *>(visitExpr(ctx->expr()));

    // 创建一个AST_OP_ASSIGN类型的中间节点，孩子为Lval和Expr
    return ast_node::New(ast_operator_type::AST_OP_ASSIGN, lvalNode, exprNode, nullptr);
}

std::any MiniCCSTVisitor::visitBlockStatement(MiniCParser::BlockStatementContext * ctx)
{
    // 识别文法产生式 blockStatement: block

    return visitBlock(ctx->block());
}

std::any MiniCCSTVisitor::visitAddExp(MiniCParser::AddExpContext * ctx)
{
    // 识别的文法产生式：addExp : mulExp (addOp mulExp)*;

    if (ctx->addOp().empty()) {
        // 没有addOp运算符，则说明闭包识别为0，只识别了第一个非终结符mulExp
        return visitMulExp(ctx->mulExp()[0]);
    }

    ast_node *left, *right;

    // 存在addOp运算符
    auto opsCtxVec = ctx->addOp();

    // 有操作符，肯定会进循环，使得right设置正确的值
    for (int k = 0; k < (int) opsCtxVec.size(); k++) {
        // 获取运算符
        ast_operator_type op = std::any_cast<ast_operator_type>(visitAddOp(opsCtxVec[k]));

        if (k == 0) {
            // 左操作数
            left = std::any_cast<ast_node *>(visitMulExp(ctx->mulExp()[k]));
        }

        // 右操作数
        right = std::any_cast<ast_node *>(visitMulExp(ctx->mulExp()[k + 1]));

        // 新建结点作为下一个运算符的右操作符
        left = ast_node::New(op, left, right, nullptr);
    }

    return left;
}

std::any MiniCCSTVisitor::visitMulExp(MiniCParser::MulExpContext * ctx)
{
    // 识别的文法产生式：mulExp : unaryExp (mulOp unaryExp)*;

    if (ctx->mulOp().empty()) {
        // 没有mulOp运算符，则说明闭包识别为0，只识别了第一个非终结符unaryExp
        return visitUnaryExp(ctx->unaryExp()[0]);
    }

    ast_node *left, *right;

    // 存在mulOp运算符
    auto opsCtxVec = ctx->mulOp();

    // 有操作符，肯定会进循环，使得right设置正确的值
    for (int k = 0; k < (int) opsCtxVec.size(); k++) {
        // 获取运算符
        ast_operator_type op = std::any_cast<ast_operator_type>(visitMulOp(opsCtxVec[k]));

        if (k == 0) {
            // 左操作数
            left = std::any_cast<ast_node *>(visitUnaryExp(ctx->unaryExp()[k]));
        }

        // 右操作数
        right = std::any_cast<ast_node *>(visitUnaryExp(ctx->unaryExp()[k + 1]));

        // 新建结点作为下一个运算符的右操作符
        left = ast_node::New(op, left, right, nullptr);
    }

    return left;
}

std::any MiniCCSTVisitor::visitMulOp(MiniCParser::MulOpContext * ctx)
{
    // 识别的文法产生式：mulOp : T_MUL | T_DIV | T_MOD
    if (ctx->T_MUL()) {
        return ast_operator_type::AST_OP_MUL;
    } else if (ctx->T_DIV()) {
        return ast_operator_type::AST_OP_DIV;
    } else if (ctx->T_MOD()) {
        return ast_operator_type::AST_OP_MOD;
    }
    return nullptr;
}

/// @brief 非终结运算符addOp的遍历
/// @param ctx CST上下文
std::any MiniCCSTVisitor::visitAddOp(MiniCParser::AddOpContext * ctx)
{
    // 识别的文法产生式：addOp : T_ADD | T_SUB

    if (ctx->T_ADD()) {
        return ast_operator_type::AST_OP_ADD;
    } else {
        return ast_operator_type::AST_OP_SUB;
    }
}

std::any MiniCCSTVisitor::visitUnaryExp(MiniCParser::UnaryExpContext * ctx)
{
    // 改进的类型转换检测逻辑
    std::string fullText = ctx->getText();

    // 检查是否可能是类型转换：以 ( 开头并包含 )
    if (fullText.find("(") == 0) {
        size_t closeParenPos = fullText.find(')');
        if (closeParenPos != std::string::npos) {
            // 提取括号内的内容
            std::string typeCandidate = fullText.substr(1, closeParenPos - 1);

            // 只有当括号内确实是有效的类型声明时才视为类型转换
            if (isValidTypeDeclaration(typeCandidate)) {
                return visitCastExpression(ctx);
            }
        }
    }

    // 一元表达式处理
    if (ctx->unaryOp() != nullptr) {
        std::string opText = ctx->unaryOp()->getText();
        ast_node * child = std::any_cast<ast_node *>(visitUnaryExp(ctx->unaryExp()));
        ast_operator_type opType;
        if (opText == "+") {
            opType = ast_operator_type::AST_OP_UNARY_PLUS;
        } else if (opText == "-") {
            opType = ast_operator_type::AST_OP_UNARY_MINUS;
        } else if (opText == "!") {
            opType = ast_operator_type::AST_OP_UNARY_NOT;
        } else {
            opType = ast_operator_type::AST_OP_UNARY_PLUS;
        }

        // 创建单目运算符节点
        ast_node * unaryNode = ast_node::New(opType, child, nullptr);

        // 立即进行优化
        return optimizeUnaryExpr(unaryNode);
    } else if (ctx->primaryExp()) {
        // 处理主表达式
        return visitPrimaryExp(ctx->primaryExp());
    } else if (ctx->T_ID()) {
        // 处理函数调用: T_ID '(' realParamList? ')'
        std::string funcName = ctx->T_ID()->getText();
        int64_t lineNo = (int64_t) ctx->T_ID()->getSymbol()->getLine();

        // 创建函数名节点
        ast_node * funcNameNode = ast_node::New(funcName, lineNo);

        // 创建函数调用节点
        ast_node * params_node = nullptr;
        if (ctx->realParamList()) {
            params_node = std::any_cast<ast_node *>(visitRealParamList(ctx->realParamList()));
        }

        return create_func_call(funcNameNode, params_node);
    }

    // 如果不匹配任何条件，返回空指针
    return std::any((ast_node *) nullptr);
}

// 改进类型转换表达式解析，将void*当作int处理
std::any MiniCCSTVisitor::visitCastExpression(MiniCParser::UnaryExpContext * ctx)
{
    std::string fullText = ctx->getText();
    size_t closeParenPos = fullText.find(')');

    if (closeParenPos == std::string::npos) {
        // 如果没有找到右括号，当作普通表达式处理
        if (ctx->primaryExp()) {
            return visitPrimaryExp(ctx->primaryExp());
        }
        return std::any((ast_node *) nullptr);
    }

    // 解析类型转换中的具体类型
    auto typeNode = parseTypeFromCast(fullText);

    // 解析被转换的表达式部分
    std::string remainingText = fullText.substr(closeParenPos + 1);
    if (!remainingText.empty()) {
        // 创建标识符节点
        auto exprNode = ast_node::New(remainingText, ctx->getStart()->getLine());

        // 对于void*类型转换，直接返回被转换的变量，类型设为int
        if (typeNode->type == IntegerType::getTypeInt()) {
            exprNode->type = IntegerType::getTypeInt();
            return exprNode;
        }

        // 其他类型转换创建CAST节点
        auto castNode = new ast_node(ast_operator_type::AST_OP_CAST);
        castNode->insert_son_node(typeNode);
        castNode->insert_son_node(exprNode);
        return castNode;
    }

    return std::any((ast_node *) nullptr);
}

std::any MiniCCSTVisitor::visitLVal(MiniCParser::LValContext * ctx)
{
    ast_node * node;

    // 改进的类型转换检测：只有括号内确实是类型时才视为类型转换
    std::string fullText = ctx->getText();
    bool isCastForm = false;

    if (fullText.find("(") == 0) {
        size_t closeParenPos = fullText.find(')');
        if (closeParenPos != std::string::npos) {
            std::string typeCandidate = fullText.substr(1, closeParenPos - 1);
            isCastForm = isValidTypeDeclaration(typeCandidate);
        }
    }

    if (isCastForm) {
        // 类型转换形式: (type*) id
        // 解析具体的类型信息
        auto typeNode = parseTypeFromCast(fullText);

        // 获取变量名
        if (ctx->T_ID() != nullptr) {
            auto baseName = ctx->T_ID()->getText();
            int64_t lineNo = (int64_t) ctx->T_ID()->getSymbol()->getLine();
            auto varNode = ast_node::New(baseName, lineNo);

            // 对于void*类型转换，直接返回变量节点，类型设为int
            if (typeNode->type == IntegerType::getTypeInt()) {
                varNode->type = IntegerType::getTypeInt();
                node = varNode;
            } 
            else {
                // 其他类型转换创建CAST节点
                auto castNode = new ast_node(ast_operator_type::AST_OP_CAST);
                castNode->insert_son_node(typeNode);
                castNode->insert_son_node(varNode);
                node = castNode;
            }
        }
    } else {
        // 普通左值形式: T_ID ('[' expr ']')*
        auto baseName = ctx->T_ID()->getText();
        int64_t lineNo = (int64_t) ctx->T_ID()->getSymbol()->getLine();
        node = ast_node::New(baseName, lineNo);

        // 新增：宏替换
        node = tryReplaceDefine(node);
    }

    // 对所有下标表达式依次生成数组访问结点
    for (auto exprCtx: ctx->expr()) {
        auto indexNode = std::any_cast<ast_node *>(visitExpr(exprCtx));
        // 创建数组访问结点：左孩子为上层表达式，右孩子为索引表达式
        node = ast_node::New(ast_operator_type::AST_OP_ARRAY_ACCESS, node, indexNode, nullptr);
    }
    return node;
}

// 修正 visitVarDef 中的类型转换检测
std::any MiniCCSTVisitor::visitVarDef(MiniCParser::VarDefContext * ctx)
{
    std::string varId;
    int64_t lineNo = -1;
    ast_node * id_node;

    // 改进的类型转换检测
    std::string fullText = ctx->getText();
    bool isCastForm = false;

    if (fullText.find("(") == 0) {
        size_t closeParenPos = fullText.find(')');
        if (closeParenPos != std::string::npos) {
            std::string typeCandidate = fullText.substr(1, closeParenPos - 1);
            isCastForm = isValidTypeDeclaration(typeCandidate);
        }
    }

    if (isCastForm) {
        // 类型转换形式: (type*) id
        // 获取变量名
        if (ctx->T_ID() != nullptr) {
            varId = ctx->T_ID()->getText();
            lineNo = (int64_t) ctx->T_ID()->getSymbol()->getLine();
        }

        // 解析具体的类型信息
        auto typeNode = parseTypeFromCast(fullText);

        // 创建变量标识符节点
        auto varNode = ast_node::New(varId, lineNo);

        // 对于void*类型转换，直接返回变量节点，类型设为int
        if (typeNode->type == IntegerType::getTypeInt()) {
            varNode->type = IntegerType::getTypeInt();
            id_node = varNode;
        } else {
            // 其他类型转换创建CAST节点
            auto castNode = new ast_node(ast_operator_type::AST_OP_CAST);
            castNode->insert_son_node(typeNode);
            castNode->insert_son_node(varNode);
            id_node = castNode;
        }
    } else {
        // 普通变量声明形式
        varId = ctx->T_ID()->getText();
        lineNo = (int64_t) ctx->T_ID()->getSymbol()->getLine();
        id_node = ast_node::New(varId, lineNo);

        // 新增：宏替换
        id_node = tryReplaceDefine(id_node);
    }

    // 如果是数组声明则调整节点（只对非类型转换形式处理）
    bool isArray = false;
    if (!isCastForm && ctx->getToken(MiniCParser::T_L_BRACKET, 0)) {
        isArray = true;
        auto leftBrackets = ctx->getTokens(MiniCParser::T_L_BRACKET);

        // 处理多维数组和常量表达式
        for (size_t i = 0; i < leftBrackets.size() && i < ctx->constExp().size(); ++i) {
            // 访问常量表达式
            auto constExpNode = std::any_cast<ast_node *>(visitConstExp(ctx->constExp(i)));
            int dimSize = 0;

            // 尝试计算常量表达式的值
            if (constExpNode->sons.size() > 0) {
                auto exprNode = constExpNode->sons[0];

                // 处理直接的整数字面量
                if (exprNode->node_type == ast_operator_type::AST_OP_LEAF_LITERAL_UINT) {
                    dimSize = exprNode->integer_val;
                }
            }

            // 创建数组声明节点
            auto array_node = ast_node::New(ast_operator_type::AST_OP_ARRAY_DECL, id_node, constExpNode, nullptr);
            array_node->integer_val = dimSize; // 存储计算出的尺寸值
            id_node = array_node;              // 更新id_node指向新创建的节点
        }
    }

    // 如果存在初始化
    if (ctx->T_ASSIGN()) {
        // 使用新的arrayInitializer处理嵌套初始化
        if (ctx->arrayInitializer()) {
            auto init_node = std::any_cast<ast_node *>(visitArrayInitializer(ctx->arrayInitializer()));

            if (isArray) {
                // 将 array_init 节点作为 array_decl 的子节点
                id_node->insert_son_node(init_node);
                return id_node;
            } else {
                // 非数组类型使用VAR_INIT
                return ast_node::New(ast_operator_type::AST_OP_VAR_INIT, id_node, init_node, nullptr);
            }
        } else if (ctx->expr()) {
            auto init_expr = std::any_cast<ast_node *>(visitExpr(ctx->expr()));

            if (isArray) {
                // 将表达式直接作为array_decl的子节点
                auto array_init_for_expr = create_contain_node(ast_operator_type::AST_OP_ARRAY_INIT, init_expr);
                id_node->insert_son_node(array_init_for_expr);
                return id_node;
            } else {
                // 非数组使用VAR_INIT
                return ast_node::New(ast_operator_type::AST_OP_VAR_INIT, id_node, init_expr, nullptr);
            }
        }
    }

    return id_node;
}

// 新增：实现常量表达式的访问方法
std::any MiniCCSTVisitor::visitConstExp(MiniCParser::ConstExpContext * ctx)
{
    // 创建常量表达式节点
    auto exprNode = std::any_cast<ast_node *>(visitAddExp(ctx->addExp()));
    // 将节点类型转换为常量表达式
    auto constExpNode = ast_node::New(ast_operator_type::AST_OP_CONST_EXP, exprNode, nullptr);
    return constExpNode;
}

// 修改：常量定义处理，支持嵌套初始化
std::any MiniCCSTVisitor::visitConstDef(MiniCParser::ConstDefContext * ctx)
{
    // 创建常量标识符节点
    ast_node * id_node = ast_node::New(ctx->T_ID()->getText(), (int64_t) ctx->T_ID()->getSymbol()->getLine());
    bool isArray = false;

    // 处理数组声明（多维数组支持）
    if (ctx->getToken(MiniCParser::T_L_BRACKET, 0)) {
        isArray = true;
        auto leftBrackets = ctx->getTokens(MiniCParser::T_L_BRACKET);
        for (size_t i = 0; i < leftBrackets.size() && i < ctx->constExp().size(); ++i) {
            auto constExpNode = std::any_cast<ast_node *>(visitConstExp(ctx->constExp(i)));
            // 创建 array_decl node, nesting previous id_node
            auto array_node = ast_node::New(ast_operator_type::AST_OP_ARRAY_DECL, id_node, constExpNode, nullptr);
            id_node = array_node; // Update id_node to be the new array_decl node
        }
    }

    // 初始化处理
    ast_node * initializer_value_node = nullptr;
    if (ctx->arrayInitializer()) {
        initializer_value_node = std::any_cast<ast_node *>(visitArrayInitializer(ctx->arrayInitializer()));
    } else if (ctx->expr()) {
        initializer_value_node = std::any_cast<ast_node *>(visitExpr(ctx->expr()));
        // If it's an array initialized by a single expression, wrap it in an array_init for consistency
        if (isArray && initializer_value_node) {
            initializer_value_node = create_contain_node(ast_operator_type::AST_OP_ARRAY_INIT, initializer_value_node);
        }
    }

    // 如果是数组并且有初始化值，则将初始化节点附加到 id_node (array_decl)
    if (isArray && initializer_value_node) {
        id_node->insert_son_node(initializer_value_node);
        // const_def 节点的第二个子节点（初始化部分）将为 nullptr，因为初始化已集成到 id_node 中
        return ast_node::New(ast_operator_type::AST_OP_CONST_DEF, id_node, nullptr);
    } else {
        // 对于非数组常量或（理论上不应发生的）无初始化器的数组常量
        return ast_node::New(ast_operator_type::AST_OP_CONST_DEF, id_node, initializer_value_node, nullptr);
    }
}

std::any MiniCCSTVisitor::visitBasicType(MiniCParser::BasicTypeContext * ctx)
{
    // basicType: T_INT | T_FLOAT;
    type_attr attr{BasicType::TYPE_VOID, -1};
    if (ctx->T_INT()) {
        attr.type = BasicType::TYPE_INT;
        attr.lineno = (int64_t) ctx->T_INT()->getSymbol()->getLine();
    } else if (ctx->T_FLOAT()) { // 新增对float的支持
        attr.type = BasicType::TYPE_FLOAT;
        attr.lineno = (int64_t) ctx->T_FLOAT()->getSymbol()->getLine();
    }
    return attr;
}

std::any MiniCCSTVisitor::visitRealParamList(MiniCParser::RealParamListContext * ctx)
{
    // 识别的文法产生式：realParamList : expr (T_COMMA expr)*;

    auto paramListNode = create_contain_node(ast_operator_type::AST_OP_FUNC_REAL_PARAMS);

    for (auto paramCtx: ctx->expr()) {

        auto paramNode = std::any_cast<ast_node *>(visitExpr(paramCtx));

        paramListNode->insert_son_node(paramNode);
    }

    return paramListNode;
}

std::any MiniCCSTVisitor::visitExpressionStatement(MiniCParser::ExpressionStatementContext * ctx)
{
    // 识别文法产生式  expr ? T_SEMICOLON #expressionStatement;
    if (ctx->expr()) {
        return visitExpr(ctx->expr());
    } else {
        return std::any((ast_node *) nullptr);
    }
}

std::any MiniCCSTVisitor::visitConstDecl(MiniCParser::ConstDeclContext * ctx)
{
    // constDecl : T_CONST basicType constDef (T_COMMA constDef)* T_SEMICOLON;
    // 创建常量声明节点
    ast_node * constDeclNode = create_contain_node(ast_operator_type::AST_OP_CONST_DECL);

    // 添加类型节点
    type_attr typeAttr = std::any_cast<type_attr>(visitBasicType(ctx->basicType()));
    ast_node * typeNode = create_type_node(typeAttr);
    constDeclNode->insert_son_node(typeNode);

    // 遍历所有常量定义，直接插入visitConstDef返回的节点
    for (size_t i = 0; i < ctx->constDef().size(); i++) {
        ast_node * defNode = std::any_cast<ast_node *>(visitConstDef(ctx->constDef()[i]));
        // 类型转换处理：如果是数组常量且有初始化器，则递归转换
        if (defNode->node_type == ast_operator_type::AST_OP_CONST_DEF && defNode->sons.size() > 0) {
            ast_node * id_node = defNode->sons[0];
            // 检查是否为数组声明且有明确的初始化器
            if (id_node && id_node->node_type == ast_operator_type::AST_OP_ARRAY_DECL && id_node->sons.size() > 1) {
                // 检查最后一个子节点是否是数组初始化器
                ast_node * last_child = id_node->sons.back();
                if (last_child->node_type == ast_operator_type::AST_OP_ARRAY_INIT) {
                    // 类型节点在constDeclNode的第一个子节点
                    Type * arrayType = nullptr;
                    if (!constDeclNode->sons.empty() && constDeclNode->sons[0]->type) {
                        arrayType = constDeclNode->sons[0]->type;
                    }
                    convertArrayInitToType(last_child, arrayType);
                }
            }
        }
        (void) constDeclNode->insert_son_node(defNode);
    }

    return constDeclNode;
}

std::any MiniCCSTVisitor::visitVarDecl(MiniCParser::VarDeclContext * ctx)
{
    // varDecl: (T_EXTERN)? basicType varDef (T_COMMA varDef)* T_SEMICOLON;
    // 创建变量声明语句的AST节点
    ast_node * stmt_node = create_contain_node(ast_operator_type::AST_OP_DECL_STMT);
    type_attr typeAttr = std::any_cast<type_attr>(visitBasicType(ctx->basicType()));

    for (auto & varCtx: ctx->varDef()) {
        // 变量名节点
        ast_node * id_node = std::any_cast<ast_node *>(visitVarDef(varCtx));

        // 创建类型节点
        ast_node * type_node = create_type_node(typeAttr);

        // 确定操作类型：数组声明用 ARRAY_DECL，否则 VAR_DECL
        ast_operator_type op;
        if (id_node->node_type == ast_operator_type::AST_OP_ARRAY_DECL ||
            (id_node->node_type == ast_operator_type::AST_OP_ARRAY_INIT && !id_node->sons.empty() &&
             id_node->sons[0]->node_type == ast_operator_type::AST_OP_ARRAY_DECL)) {
            op = ast_operator_type::AST_OP_ARRAY_DECL;
        } else {
            op = ast_operator_type::AST_OP_VAR_DECL;
        }

        // 类型转换处理：如果是数组变量且有初始化器，则递归转换
        if (id_node->node_type == ast_operator_type::AST_OP_ARRAY_DECL && id_node->sons.size() > 1) {
            // 检查最后一个子节点是否是数组初始化器
            ast_node * last_child = id_node->sons.back();
            if (last_child->node_type == ast_operator_type::AST_OP_ARRAY_INIT) {
                Type * arrayType = nullptr;
                if (type_node && type_node->type) {
                    arrayType = type_node->type;
                }
                convertArrayInitToType(last_child, arrayType);
            }
        }

        ast_node * decl_node = ast_node::New(op, type_node, id_node, nullptr);

        (void) stmt_node->insert_son_node(decl_node);
    }

    return stmt_node;
}

std::any MiniCCSTVisitor::visitIfStatement(MiniCParser::IfStatementContext * ctx)
{
    // 解析条件表达式
    auto condNode = std::any_cast<ast_node *>(visitExpr(ctx->expr()));
    auto thenNode = std::any_cast<ast_node *>(visitStatement(ctx->statement(0)));
    ast_node * ifNode = new ast_node(ast_operator_type::AST_OP_IF);
    ifNode->insert_son_node(condNode);
    ifNode->insert_son_node(thenNode);
    if (ctx->T_ELSE() != nullptr) {
        auto elseStmt = std::any_cast<ast_node *>(visitStatement(ctx->statement(1)));
        // 创建一个 else 节点包装 else 分支
        ast_node * elseWrapper = new ast_node(ast_operator_type::AST_OP_ELSE);
        elseWrapper->insert_son_node(elseStmt);
        ifNode->insert_son_node(elseWrapper);
    }
    return ifNode;
}

// 新增：处理 while 语句，解析条件和循环体
std::any MiniCCSTVisitor::visitWhileStatement(MiniCParser::WhileStatementContext * ctx)
{
    auto condNode = std::any_cast<ast_node *>(visitExpr(ctx->expr()));
    auto stmtNode = std::any_cast<ast_node *>(visitStatement(ctx->statement()));
    return ast_node::New(ast_operator_type::AST_OP_WHILE, condNode, stmtNode, nullptr);
}

// 新增：处理 break 语句
std::any MiniCCSTVisitor::visitBreakStatement(MiniCParser::BreakStatementContext * ctx)
{
    return new ast_node(ast_operator_type::AST_OP_BREAK);
}

// 新增：处理 continue 语句
std::any MiniCCSTVisitor::visitContinueStatement(MiniCParser::ContinueStatementContext * ctx)
{
    return new ast_node(ast_operator_type::AST_OP_CONTINUE);
}

// 新增：宏替换辅助函数实现
ast_node* MiniCCSTVisitor::tryReplaceDefine(ast_node* node)
{
    if (!node) return nullptr;
    if (node->node_type == ast_operator_type::AST_OP_LEAF_VAR_ID) {
        auto it = define_macros.find(node->name);
        if (it != define_macros.end() && it->second) {
            // 返回宏值的深拷贝，避免多处共享同一节点（这里只做浅拷贝，实际可根据需要实现深拷贝）
            return it->second;
        }
    }
    return node;
}

// 修改：visitDefineDecl，收集define宏
std::any MiniCCSTVisitor::visitDefineDecl(MiniCParser::DefineDeclContext * ctx)
{
    // defineDecl: T_DEFINE T_ID expr T_SEMICOLON;

    // 创建宏定义声明节点
    ast_node * defineDeclNode = create_contain_node(ast_operator_type::AST_OP_DEFINE_DECL);

    // 获取宏名称
    std::string macroName = ctx->T_ID()->getText();
    int64_t lineNo = (int64_t) ctx->T_ID()->getSymbol()->getLine();
    ast_node * nameNode = ast_node::New(macroName, lineNo);

    // 获取宏值表达式
    ast_node * valueNode = std::any_cast<ast_node *>(visitExpr(ctx->expr()));

    // 新增：保存到define宏表
    define_macros[macroName] = valueNode;

    // 创建宏定义节点
    ast_node * defineDefNode = ast_node::New(ast_operator_type::AST_OP_DEFINE_DEF, nameNode, valueNode, nullptr);
    defineDefNode->name = macroName;
    defineDefNode->line_no = lineNo;

    // 将宏定义节点添加到声明节点
    defineDeclNode->insert_son_node(defineDefNode);

    return defineDeclNode;
}

// 修改：visitPrimaryExp，变量ID节点宏替换
std::any MiniCCSTVisitor::visitPrimaryExp(MiniCParser::PrimaryExpContext * ctx)
{
    // 识别文法产生式 primaryExp: T_L_PAREN expr T_R_PAREN | T_DIGIT | lVal;

    ast_node * node = nullptr;

    if (ctx->T_FLOAT_LITERAL()) {
        float val = std::stof(ctx->T_FLOAT_LITERAL()->getText());
        int64_t lineNo = (int64_t) ctx->T_FLOAT_LITERAL()->getSymbol()->getLine();
        node = new ast_node(val, lineNo);
    } else if (ctx->T_HEX_FLOAT_LITERAL()) { // 新增：处理十六进制浮点数字面量
        std::string text = ctx->T_HEX_FLOAT_LITERAL()->getText();
        // 解析十六进制浮点数
        float val = parseHexFloat(text);
        int64_t lineNo = (int64_t) ctx->T_HEX_FLOAT_LITERAL()->getSymbol()->getLine();
        node = new ast_node(val, lineNo);
    } else if (ctx->T_HEX_LITERAL()) { // 新增：处理十六进制字面量
        std::string text = ctx->T_HEX_LITERAL()->getText();
        uint32_t val = (uint32_t) std::stoull(text, nullptr, 16);
        int64_t lineNo = (int64_t) ctx->T_HEX_LITERAL()->getSymbol()->getLine();
        node = ast_node::New(digit_int_attr{val, lineNo});
    } else if (ctx->T_OCT_LITERAL()) { // 新增：处理八进制字面量
        std::string text = ctx->T_OCT_LITERAL()->getText();
        uint32_t val = (uint32_t) std::stoull(text, nullptr, 8);
        int64_t lineNo = (int64_t) ctx->T_OCT_LITERAL()->getSymbol()->getLine();
        node = ast_node::New(digit_int_attr{val, lineNo});
    } else if (ctx->T_DIGIT()) {
        // 无符号整型字面量
        // 识别 primaryExp: T_DIGIT

        uint32_t val = (uint32_t) stoull(ctx->T_DIGIT()->getText());
        int64_t lineNo = (int64_t) ctx->T_DIGIT()->getSymbol()->getLine();
        node = ast_node::New(digit_int_attr{val, lineNo});
    } else if (ctx->lVal()) {
        // 具有左值的表达式
        // 识别 primaryExp: lVal
        node = std::any_cast<ast_node *>(visitLVal(ctx->lVal()));
        // 新增：宏替换
        node = tryReplaceDefine(node);
    } else if (ctx->expr()) {
        // 带有括号的表达式
        // primaryExp: T_L_PAREN expr T_R_PAREN
        node = std::any_cast<ast_node *>(visitExpr(ctx->expr()));
    }

    return node;
}

// 新增：解析十六进制浮点数的辅助函数
float MiniCCSTVisitor::parseHexFloat(const std::string & hexFloatStr)
{
    // 解析形如 "0x1.23p4" 的十六进制浮点数
    size_t xPos = hexFloatStr.find_first_of("xX");
    size_t pPos = hexFloatStr.find_first_of("pP");

    if (xPos == std::string::npos || pPos == std::string::npos) {
        return 0.0f;
    }

    std::string hexPart = hexFloatStr.substr(xPos + 1, pPos - xPos - 1);
    std::string expPart = hexFloatStr.substr(pPos + 1);

    // 解析十六进制部分
    float hexValue = 0.0f;
    size_t dotPos = hexPart.find('.');

    if (dotPos != std::string::npos) {
        // 有小数点
        std::string intPart = hexPart.substr(0, dotPos);
        std::string fracPart = hexPart.substr(dotPos + 1);

        // 整数部分
        for (char c: intPart) {
            hexValue = hexValue * 16 + (isdigit(c) ? c - '0' : tolower(c) - 'a' + 10);
        }

        // 小数部分
        float fracValue = 0.0f;
        float factor = 1.0f / 16.0f;
        for (char c: fracPart) {
            fracValue += (isdigit(c) ? c - '0' : tolower(c) - 'a' + 10) * factor;
            factor /= 16.0f;
        }
        hexValue += fracValue;
    } else {
        // 没有小数点
        for (char c: hexPart) {
            hexValue = hexValue * 16 + (isdigit(c) ? c - '0' : tolower(c) - 'a' + 10);
        }
    }

    // 解析指数部分
    int exponent = std::stoi(expPart);

    // 应用二进制指数
    return hexValue * std::pow(2.0f, exponent);
}

// 新增：递归将数组初始化器中的整数字面量转换为float类型
ast_node * MiniCCSTVisitor::convertArrayInitToType(ast_node * initNode, Type * targetType)
{
    if (!initNode || !targetType) {
        return nullptr;
    }

    // 检查节点类型 - 只处理数组初始化器节点
    if (initNode->node_type != ast_operator_type::AST_OP_ARRAY_INIT) {
        return initNode;
    }

    // 递归处理所有子节点
    for (auto child: initNode->sons) {
        if (child->node_type == ast_operator_type::AST_OP_ARRAY_INIT) {
            // 递归处理嵌套的数组初始化器
            convertArrayInitToType(child, targetType);
        } else if (child->node_type == ast_operator_type::AST_OP_LEAF_LITERAL_UINT) {
            // 检查是否需要转换为float类型
            if (targetType->toString() == "float") {
                // 将整数字面量转换为浮点数
                float floatVal = static_cast<float>(child->integer_val);

                // 创建新的浮点数节点替换原来的整数节点
                ast_node * floatNode = new ast_node(floatVal, child->line_no);

                // 替换子节点
                for (size_t i = 0; i < initNode->sons.size(); i++) {
                    if (initNode->sons[i] == child) {
                        initNode->sons[i] = floatNode;
                        delete child; // 释放原节点内存
                        break;
                    }
                }
            }
        }
    }

    return initNode;
}